home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / StaticTView.h < prev    next >
C/C++ Source or Header  |  1990-11-28  |  7KB  |  211 lines
  1. #ifndef StaticTView_First
  2. #ifdef __GNUG__
  3. #pragma once
  4. #endif
  5. #define StaticTView_First
  6.  
  7. #include "Text.h"
  8. #include "Mark.h"
  9. #include "ObjArray.h"
  10. #include "View.h"
  11.  
  12. enum eTextJust {                               // text justification 
  13.     eLeft, 
  14.     eRight, 
  15.     eCenter, 
  16.     eJustified  
  17. };
  18.  
  19. enum eSpacing  {                                // line spacing
  20.     eOne        = 2, 
  21.     eOneHalf    = 3, 
  22.     eTwo        = 4 
  23. };
  24.  
  25. enum TextViewFlags {
  26.     eTextViewNone       =   0,
  27.     eTextViewReadOnly   =   BIT(eViewLast+1),   // disable text modifications
  28.     eTextViewVisMode    =   BIT(eViewLast+2),   // show new line characters
  29.     eTextFormPreempt    =   BIT(eViewLast+3),   // is formating process preemptive
  30.     eTextFixedOrigin    =   BIT(eViewLast+4),   // if contentRect.width is set to
  31.                         // cFit and the justification is eRight or
  32.                         // eCenter, should the origin of the text 
  33.                         // remain fixed
  34.     eTextViewNoBatch    =   BIT(eViewLast+5),   // do not batch characters in DoKeyCommand
  35.     eTextFixedSpacing   =   BIT(eViewLast+6),   // use fixed line spaceing
  36.     eTextNoFind         =   BIT(eViewLast+7),   // do not add "find" menu
  37.     eTextViewLast       =   eViewLast+7,     
  38.     eTextViewDefault    =   eVObjEnabled
  39. };
  40.  
  41. extern Rectangle gFitRect;
  42.  
  43. const int cFit = -1;
  44.  
  45. //---- line mark ------------------------------------------------------------
  46.  
  47. extern int LineMark_lineChanged;    // height or baseheight of a line has changed 
  48.  
  49. struct LineMark: public Mark {
  50.     LineDesc ld;
  51.  
  52.     MetaDef(LineMark);
  53.  
  54.     LineMark(LineDesc ldesc, int pos= 0, int len= 0, eMarkState s= eStateNone);
  55.     ~LineMark();
  56.     void ChangeMark (int pos, int len, LineDesc ldesc, eMarkState s = eStateNone)
  57.     { if (!LineMark_lineChanged) 
  58.         LineMark_lineChanged= !ld.IsEqual(ldesc);
  59.       Mark::ChangeMark(pos,len,s); 
  60.       ld = ldesc;
  61.     }
  62.     ostream& DisplayOn (ostream&s);
  63.  
  64.     //---- memory allocation
  65.     void *operator new (size_t);
  66.     void operator delete(void *vp);
  67. };
  68.  
  69. //---- global functions ----------------------------------------------------
  70.  
  71. int TextViewLineHeight(FontPtr fd = gSysFont, eSpacing sp = eOne); 
  72.     // return the height of a textline
  73.  
  74. inline int TextViewlh(eSpacing sp, int h)
  75. {
  76.     return sp == eOne ? h: ((int)sp)*h/2;
  77. }
  78.  
  79. //---- TextView -------------------------------------------------------------
  80.  
  81. class StaticTextView: public View {
  82. protected:
  83.     Text *text;                 // shown text
  84.     class TextFormatter *formatter; // formatter
  85.     eTextJust just;             // justification
  86.     eSpacing spacing;           // spacing between two lines
  87.     bool wrap;                  // break line at view boundary
  88.     bool drawViewBorder;        
  89.     bool vertExtend,horExtend;  // determine vertExtend, horExtend depending
  90.                 // on text
  91.     Point border;               // border around the text
  92.  
  93.     int nLines;                 // number of lines
  94.     ObjArray *lines;            // array of line marks, grows dynamically
  95.     MarkList *marks;            // notice: this set of marks is managed by
  96.                 // members of the class StaticTextView not by
  97.                 // an instance of Text   
  98.     class TextIter *nextc;      // iterator of currently loaded text
  99.     LineDesc fixedSpacing;      // line spacing to use with fixed line spaceing
  100.  
  101. public:
  102.     MetaDef(StaticTextView);
  103.     int FirstCharPos (int start,int end); 
  104.     // position of first char on a line
  105.     
  106.     //---- called from formatter
  107.     bool MarkLine(int line, int start, int end, LineDesc *ld); 
  108.     // add a line mark and return if the line changed
  109.     void MarkLineAsChanged(int line);
  110.     bool SuspendFormatting();
  111.     virtual void StartFormatting();
  112.     
  113.     void Init(Rectangle, Text*, eTextJust, eSpacing, bool wrap, TextViewFlags,Point);
  114.     bool IsJustified(int endOfLine);
  115.     virtual int OutOfRangeLineMetric(bool lineHeight);   
  116.  
  117.  
  118.     StaticTextView(EvtHandler *eh, Rectangle r, Text *t, eTextJust m= eLeft,
  119.          eSpacing= eOne, bool wrap= TRUE,
  120.          TextViewFlags= eTextViewDefault, 
  121.          Point border= gBorder, int id= cIdNone);    
  122.         // contentRect.width/height can be set to cFit, see above
  123.  
  124.     ~StaticTextView();
  125.  
  126.     void Draw(Rectangle);
  127.     virtual void DrawLine (Point p,int line,Rectangle lineRect, Rectangle clip);
  128.     virtual void Reformat();                  // reformat and redisplay whole text
  129.     virtual void ChangedAt(int line, int ch = 0, bool redrawAll = FALSE, int minUpto = 0);
  130.     // format text starting at 'line' at least up to line 'minupto'
  131.     virtual void InvalidateRange(int from, int to);
  132.     virtual void InvalidateRange(int from, Point fp, int to, Point tp);
  133.  
  134.     virtual Text *SetText(Text*);     // returns old text
  135.     void SetFormatter(TextFormatter *f);       
  136.     virtual void SetString(byte *str, int len= -1);
  137.     Text *GetText()
  138.     { return text; }
  139.  
  140.     //---- acessing
  141.     void SetSpacing (eSpacing);
  142.     eSpacing GetSpacing()
  143.     { return spacing; }
  144.     virtual void SetFont(FontPtr fd);
  145.     FontPtr GetFont()
  146.     { return text->GetFont(); }
  147.     eTextJust GetJust() 
  148.     { return just; }
  149.     void SetJust(eTextJust);
  150.     void SetVisibleMode(bool);
  151.     bool GetVisibleMode();
  152.     void SetNoBatch(bool);
  153.     bool GetNoBatch();
  154.     void SetWordWrap(bool m);
  155.     bool GetWordWrap();
  156.     bool Empty()
  157.     { return (bool) (text->Size() == 0); }
  158.     int NumberOfLines();
  159.  
  160.     //---- mapping
  161.     virtual void PointToPos(Point p,Point *viewPos,int *lineNo,int *CharNo); // viewPos.y ???
  162.     virtual void CharToPos (int charNo,int *lineNo,Point *viewPos, bool relative = TRUE);
  163.     virtual Point LineToPoint (int line, bool basePoint = FALSE, bool relative = TRUE);
  164.     virtual int PointToLine (Point p);
  165.     virtual int CharToLine(int ch);   // return line number of character
  166.  
  167.     //---- line structure access
  168.     LineMark *MarkAtLine(int i)
  169.     { return (LineMark*)(*lines)[i]; }
  170.     int StartLine(int l)
  171.     { return MarkAtLine(l)->pos; }
  172.     int EndLine(int l)
  173.     { return MarkAtLine(l)->pos + MarkAtLine(l)->len; }
  174.     int LineHeight(int l);
  175.     int BaseHeight(int l);
  176.     
  177.     //---- size managment
  178.     virtual void Fit();     
  179.     // adapt view size to the extension of text if wrap is set to TRUE only 
  180.     // the height is changed
  181.     void SetExtent(Point p); // (reformats text)
  182.     Metric GetMinSize();
  183.     int Base();
  184.     Point GetInnerOrigin()  // 
  185.     { return contentRect.origin+border; }
  186.     Point GetInnerExtent()  
  187.     { return contentRect.extent-2*border; }
  188.     void SetBorder(Point newBorder)
  189.     { border= newBorder; }
  190.     Point GetBorder()
  191.     { return border; }
  192.  
  193.     //----- client marks    
  194.     void AddMark(Mark *);
  195.     Mark *RemoveMark(Mark *);
  196.     Iterator *GetMarkIter(); 
  197.     MarkList *GetMarkList();    
  198.  
  199.     //----- debugging
  200.     virtual void Dump();
  201.     void InspectorId(char *buf, int sz);
  202.     void Parts(Collection*);
  203.  
  204.     //----- generic methods
  205.     char *AsString();
  206.     ostream& PrintOn (ostream&s);
  207.     istream& ReadFrom(istream &s);
  208. };
  209.  
  210. #endif StaticTView_First     
  211.